import pandas as pd
import numpy as np
import panel as pn
import hvplot.pandas
import ssl
import seaborn as sns
import matplotlib.pyplot as plt
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import OneHotEncoder, StandardScaler
from sklearn.linear_model import LinearRegression
from sklearn.metrics import mean_squared_error, r2_score


from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import train_test_split, cross_val_score
from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score

# Configuration initiale
pn.extension('tabulator', template='fast')
ssl._create_default_https_context = ssl._create_unverified_context

# Chargement des données avec cache
@pn.cache
def load_adult_data():
    url = "https://archive.ics.uci.edu/ml/machine-learning-databases/adult/adult.data"
    column_names = [
        "age", "workclass", "fnlwgt", "education", "education-num", 
        "marital-status", "occupation", "relationship", "race", "sex", 
        "capital-gain", "capital-loss", "hours-per-week", "native-country", "income"
    ]
    return pd.read_csv(url, names=column_names, sep=",", header=None, skipinitialspace=True)

# Création du tableau interactif
def create_interactive_table(df):
    return pn.widgets.Tabulator(
        df,
        pagination='remote',
        page_size=20,
        sizing_mode='stretch_width',
        configuration={
            'layout': 'fitDataStretch',
            'columnDefaults': {
                'headerFilter': True,
                'hozAlign': 'left'
            }
        }
    )

# Dashboard complet
adult_dashboard = pn.Column(
    "##  Exploration Interactive du Dataset Adult",
    "### Source : UCI Machine Learning Repository",
    pn.Row(
        pn.Column(
            "### Paramètres",
            # CORRECTION : Conversion des colonnes en liste avec .tolist()
            pn.widgets.Select(name='Tri par colonne', options=load_adult_data().columns.tolist()),
            pn.widgets.IntSlider(name='Lignes par page', start=10, end=100, step=10, value=20)
        ),
        create_interactive_table(load_adult_data())
    ),
    sizing_mode='stretch_both'
)

# Affichage du dashboard
adult_dashboard.servable()

# Désactiver la vérification SSL
ssl._create_default_https_context = ssl._create_unverified_context

# URL du dataset
url_adult = "https://archive.ics.uci.edu/ml/machine-learning-databases/adult/adult.data"

# Noms des colonnes
column_names_adult = [
    "age", "workclass", "fnlwgt", "education", "education-num", "marital-status",
    "occupation", "relationship", "race", "sex", "capital-gain", "capital-loss",
    "hours-per-week", "native-country", "income"
]

# Chargement des données avec mise en cache
if 'data_adult' not in pn.state.cache.keys():
    df_adult = pd.read_csv(
        url_adult, names=column_names_adult, sep=",", header=None, skipinitialspace=True
    )

    # Suppression des espaces superflus dans les colonnes textuelles
    str_cols = df_adult.select_dtypes(object).columns
    df_adult[str_cols] = df_adult[str_cols].apply(lambda x: x.str.strip())
    
    # Identification des doublons
    duplicated_rows = df_adult[df_adult.duplicated(keep=False)]
    
    # Stockage en cache
    pn.state.cache['data_adult'] = df_adult.copy()
    pn.state.cache['duplicated_data'] = duplicated_rows.copy()
else:
    df_adult = pn.state.cache['data_adult']
    duplicated_rows = pn.state.cache.get('duplicated_data', pd.DataFrame())

# Vérification correcte des doublons
duplicated_rows = df_adult[df_adult.duplicated(keep=False)].copy()

# Fonction pour créer un tableau interactif
def create_interactive_table(df):
    if df.empty:
        return pn.pane.Markdown("### Aucun doublon trouvé, mais vérifiez les données.", width=400)
    
    return pn.widgets.Tabulator(
        df,
        pagination='remote',
        page_size=20,
        sizing_mode='stretch_width',
        configuration={
            'layout': 'fitDataStretch',
            'columnDefaults': {
                'headerFilter': True,
                'hozAlign': 'left'
            }
        }
    )

# Dashboard complet
dashboard = pn.Column(
    "##  Exploration Interactive des Doublons du Dataset Adult",
    "### Source : UCI Machine Learning Repository",
    "##  Doublons Identifiés",
    create_interactive_table(duplicated_rows),
    sizing_mode='stretch_both'
)

dashboard.servable()

# Activer Panel avec Tabulator
pn.extension('tabulator')

# Désactiver la vérification SSL
ssl._create_default_https_context = ssl._create_unverified_context

# URL du dataset
url_adult = "https://archive.ics.uci.edu/ml/machine-learning-databases/adult/adult.data"

# Noms des colonnes
column_names_adult = [
    "age", "workclass", "fnlwgt", "education", "education-num", "marital-status",
    "occupation", "relationship", "race", "sex", "capital-gain", "capital-loss",
    "hours-per-week", "native-country", "income"
]

# Chargement des données avec mise en cache
if 'data_adult' not in pn.state.cache.keys():
    df_adult = pd.read_csv(
        url_adult, names=column_names_adult, sep=",", header=None, skipinitialspace=True
    )

    # Suppression des espaces superflus dans les colonnes textuelles
    str_cols = df_adult.select_dtypes(object).columns
    df_adult[str_cols] = df_adult[str_cols].apply(lambda x: x.str.strip())

    # Stockage en cache
    pn.state.cache['data_adult'] = df_adult.copy()
else:
    df_adult = pn.state.cache['data_adult']

# Détection des valeurs "?"
missing_mask = df_adult == "?"

# Création d'une copie du DataFrame pour affichage HTML
df_display = df_adult.copy()

# Remplacement des valeurs "?" par une version colorée en HTML
for col in df_adult.columns:
    df_display[col] = df_adult[col].apply(
        lambda x: f'<span style="background-color:red; color:white; font-weight:bold; padding:3px;">{x}</span>' 
        if x == "?" else x
    )

# Récapitulatif des valeurs "?" par colonne
missing_counts = missing_mask.sum().reset_index()
missing_counts.columns = ["Variable", "Nombre de valeurs '?'"]

# Mise en couleur des cellules ayant des valeurs manquantes
for col in missing_counts.columns:
    missing_counts[col] = missing_counts[col].astype(str)

missing_counts["Nombre de valeurs '?'"] = missing_counts["Nombre de valeurs '?'"].apply(
    lambda x: f'<span style="background-color:red; color:white; font-weight:bold; padding:3px;">{x}</span>'
    if x != "0" else x
)

# Création du tableau interactif avec mise en rouge des valeurs non nulles
missing_table = pn.widgets.Tabulator(
    missing_counts,
    pagination='remote', 
    page_size=20,
    formatters={col: {"type": "html"} for col in missing_counts.columns},  # Activation HTML
    configuration={"layout": "fitDataStretch"}
)

# Configuration du tableau principal avec formatage HTML
table = pn.widgets.Tabulator(
    df_display, 
    pagination='remote', 
    page_size=10, 
    formatters={col: {"type": "html"} for col in df_adult.columns},  # Activer l'affichage HTML
    configuration={"layout": "fitDataStretch"}
)

# Affichage interactif du tableau avec le résumé des valeurs manquantes
dashboard = pn.Column(
    "## 📋 Tableau des données avec valeurs `?` mises en rouge",
    table,
    "# Dataset Adult - Valeurs manquantes",
    "🔴 **Toutes les cellules contenant `?` sont colorées en rouge.**",
    "## Nombre de valeurs `?` par colonne (les valeurs non nulles sont mises en rouge)",
    "## variables catégorielles contenant des valeurs manquantes sont: workclass, occupation, native-country" ,
    missing_table,
    
)

dashboard.servable()

# Afficher la nature des variables catégorielles contenant des valeurs manquantes
categorical_columns_with_missing = ["workclass", "occupation", "native-country"]

# Affichage des premières valeurs uniques pour chaque variable concernée
nature_variables = {col: df_adult[col].unique()[:10] for col in categorical_columns_with_missing}

# Convertir en DataFrame pour une meilleure lisibilité
df_nature_variables = pd.DataFrame(dict([(k, pd.Series(v)) for k, v in nature_variables.items()]))

display(df_nature_variables)

import sidetable 
valeur_manquante=df_adult.stb.missing()
# Affichage interactif avec Panel
table_val_manquante = pn.widgets.Tabulator(valeur_manquante, pagination='remote', page_size=10)

# Affichage des  premières lignes
pn.Column("# Aperçu des Valeurs Manquantes", table_val_manquante).servable()

df_adult.duplicated().sum() # Pas de doublon

24

import ssl
import pandas as pd
import panel as pn
from sklearn.ensemble import RandomForestClassifier, RandomForestRegressor
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score, r2_score, mean_squared_error
import numpy as np

# Activer Panel avec Tabulator
pn.extension('tabulator')

# Désactiver la vérification SSL
ssl._create_default_https_context = ssl._create_unverified_context

# URL du dataset
url_adult = "https://archive.ics.uci.edu/ml/machine-learning-databases/adult/adult.data"

# Noms des colonnes
column_names_adult = [
    "age", "workclass", "fnlwgt", "education", "education-num", "marital-status",
    "occupation", "relationship", "race", "sex", "capital-gain", "capital-loss",
    "hours-per-week", "native-country", "income"
]

# Chargement des données avec mise en cache
if 'data_adult' not in pn.state.cache.keys():
    df_adult = pd.read_csv(
        url_adult, names=column_names_adult, sep=",", header=None, skipinitialspace=True
    )

    # Suppression des espaces superflus dans les colonnes textuelles
    str_cols = df_adult.select_dtypes(object).columns
    df_adult[str_cols] = df_adult[str_cols].apply(lambda x: x.str.strip())

    # Stockage en cache
    pn.state.cache['data_adult'] = df_adult.copy()
else:
    df_adult = pn.state.cache['data_adult']

# Détection des valeurs "?"
missing_mask = df_adult == "?"

# Fonctions de traitement des valeurs manquantes
def drop_missing_values(df):
    return df.replace("?", pd.NA).dropna()

def impute_unknown(df):
    return df.replace("?", "Unknown")

def impute_mode(df):
    for col in df.columns:
        if df[col].dtype == "object":
            mode = df[col].mode()[0]
            df[col] = df[col].replace("?", mode)
    return df

def random_forest_imputation(df):
    df = df.replace("?", pd.NA)
    for col in df.columns:
        if df[col].isna().any():
            train = df[df[col].notna()]
            test = df[df[col].isna()]
            X_train = train.drop(columns=[col])
            y_train = train[col]
            X_test = test.drop(columns=[col])
            X_train = pd.get_dummies(X_train)
            X_test = pd.get_dummies(X_test)
            X_test = X_test.reindex(columns=X_train.columns, fill_value=0)
            model = RandomForestClassifier()
            model.fit(X_train, y_train)
            df.loc[df[col].isna(), col] = model.predict(X_test)
    return df

# Application des méthodes
df_drop = drop_missing_values(df_adult.copy())
df_unknown = impute_unknown(df_adult.copy())
df_mode = impute_mode(df_adult.copy())
df_rf = random_forest_imputation(df_adult.copy())

# Conversion de la variable cible
def prepare_data(df):
    df = df.copy()
    df["income"] = df["income"].apply(lambda x: 1 if x == ">50K" else 0)
    df = pd.get_dummies(df.dropna(), drop_first=True)
    return df

def evaluate_model(df, method_name):
    df = prepare_data(df)
    X = df.drop(columns=["income"])
    y = df["income"]
    X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
    model = RandomForestClassifier()
    model.fit(X_train, y_train)
    y_pred = model.predict(X_test)
    r2 = r2_score(y_test, y_pred)
    rmse = np.sqrt(mean_squared_error(y_test, y_pred))
    dataset_size = len(df)
    missing_values = df.isna().sum().sum()
    return {"Méthode": method_name, "R^2": r2, "RMSE": rmse, "Taille du dataset": dataset_size, "Valeurs manquantes restantes": missing_values}

# Évaluation des méthodes
results = [
    evaluate_model(df_drop, "Suppression"),
    evaluate_model(df_unknown, "Imputation 'Unknown'"),
    evaluate_model(df_mode, "Imputation par mode"),
    evaluate_model(df_rf, "Forêt aléatoire")
]

# Déterminer la meilleure méthode
def find_best_method(results):
    df_results = pd.DataFrame(results)
    best_method = df_results.sort_values(by=["R^2", "RMSE"], ascending=[False, True]).iloc[0]
    return best_method["Méthode"]

best_method = find_best_method(results)

# Résultats sous forme de DataFrame
results_df = pd.DataFrame(results)
results_table = pn.widgets.Tabulator(
    results_df,
    pagination='remote',
    page_size=10,
    configuration={"layout": "fitDataStretch"}
)

# Affichage interactif
dashboard = pn.Column(
    "## 📋 Tableau des données avec valeurs `?` mises en rouge",
    "# 📊 Comparaison des méthodes de traitement des valeurs manquantes",
    results_table,
    f"### 🏆 Meilleure méthode identifiée : **{best_method}**"
)

dashboard.servable()

import ssl
import pandas as pd
import panel as pn
import numpy as np
import statsmodels.api as sm
import seaborn as sns
import matplotlib.pyplot as plt
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.metrics import mean_squared_error, r2_score
from statsmodels.stats.outliers_influence import variance_inflation_factor
from sklearn.ensemble import RandomForestRegressor

# Activer Panel avec Tabulator
pn.extension('tabulator')

# Désactiver la vérification SSL
ssl._create_default_https_context = ssl._create_unverified_context

# URL du dataset
url_adult = "https://archive.ics.uci.edu/ml/machine-learning-databases/adult/adult.data"

# Noms des colonnes
column_names_adult = [
    "age", "workclass", "fnlwgt", "education", "education-num", "marital-status",
    "occupation", "relationship", "race", "sex", "capital-gain", "capital-loss",
    "hours-per-week", "native-country", "income"
]

# Chargement des données avec mise en cache
if 'data_adult' not in pn.state.cache.keys():
    df_adult = pd.read_csv(
        url_adult, names=column_names_adult, sep=",", header=None, skipinitialspace=True
    )

    # Suppression des espaces superflus dans les colonnes textuelles
    str_cols = df_adult.select_dtypes(object).columns
    df_adult[str_cols] = df_adult[str_cols].apply(lambda x: x.str.strip())

    # Stockage en cache
    pn.state.cache['data_adult'] = df_adult.copy()
else:
    df_adult = pn.state.cache['data_adult']

# Détection des valeurs "?"
def impute_mode(df):
    for col in df.columns:
        if df[col].dtype == "object":
            mode = df[col].mode()[0]
            df[col] = df[col].replace("?", mode)
    return df

# Application de la meilleure méthode d'imputation (par mode ici)
df_best = impute_mode(df_adult.copy())

# Suppression de la colonne inutile "fnlwgt"
df_best.drop(columns=["fnlwgt"], inplace=True)

# Encodage one-hot des variables catégoriques
df_best = pd.get_dummies(df_best, drop_first=True)

# Sélection des variables indépendantes et dépendantes
X = df_best.drop(columns=["hours-per-week"])
y = df_best["hours-per-week"]

# Identification des variables les plus influentes avec Random Forest
rf_model = RandomForestRegressor(n_estimators=100, random_state=42)
rf_model.fit(X, y)
feature_importances = pd.DataFrame({
    'Variable': X.columns,
    'Importance': rf_model.feature_importances_
}).sort_values(by='Importance', ascending=False)

# Sélection des variables les plus influentes (seuil > 0.01 pour éviter le bruit)
important_features = feature_importances[feature_importances["Importance"] > 0.01]["Variable"].tolist()
X = X[important_features]

# Standardisation des variables
scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)
X_scaled = pd.DataFrame(X_scaled, columns=X.columns)

# Ajout de la constante pour le modèle de régression multiple
X_scaled = sm.add_constant(X_scaled)

# Séparation en ensemble d'entraînement et de test
X_train, X_test, y_train, y_test = train_test_split(X_scaled, y, test_size=0.2, random_state=42)

# Modèle de régression multiple
model = sm.OLS(y_train, X_train).fit()
y_pred = model.predict(X_test)

# Évaluation du modèle
r2 = r2_score(y_test, y_pred)
rmse = np.sqrt(mean_squared_error(y_test, y_pred))
adj_r2 = model.rsquared_adj

# Vérification des hypothèses de régression
# 1. Multicolinéarité (Variance Inflation Factor - VIF)
def calculate_vif(X):
    vif_data = pd.DataFrame()
    vif_data["Variable"] = X.columns
    vif_values = []
    for i in range(X.shape[1]):
        try:
            vif = variance_inflation_factor(X.values, i)
            vif_values.append(vif)
        except:
            vif_values.append(np.nan)
    vif_data["VIF"] = vif_values
    return vif_data.dropna()

vif_results = calculate_vif(X_scaled)

# 2. Normalité des résidus
residuals = y_test - y_pred

# 3. Homoscédasticité (test visuel avec les résidus)
def plot_residuals(y_test, y_pred, residuals):
    fig, axes = plt.subplots(1, 2, figsize=(12, 5))
    sns.histplot(residuals, kde=True, ax=axes[0], bins=50)
    axes[0].set_title("Distribution des Résidus")
    
    sns.scatterplot(x=y_pred, y=residuals, ax=axes[1], alpha=0.5)
    axes[1].axhline(y=0, color='red', linestyle='--')
    axes[1].set_xlabel("Valeurs Prédites")
    axes[1].set_ylabel("Résidus")
    axes[1].set_title("Graphique des Résidus")
    
    plt.show()

plot_residuals(y_test, y_pred, residuals)

# Affichage des résultats
dashboard = pn.Column(
    "##  Régression Multiple : Prédiction du Temps de Travail Hebdomadaire",
    f"###  R² ajusté : {adj_r2:.4f}",
    f"###  RMSE : {rmse:.4f}",
    "## Variables les plus influentes",
    pn.widgets.Tabulator(feature_importances, pagination='remote', page_size=10, configuration={"layout": "fitDataStretch"}),
    "##  Analyse de la Multicolinéarité (VIF)",
    pn.widgets.Tabulator(vif_results, pagination='remote', page_size=10, configuration={"layout": "fitDataStretch"}),
    "##  Résumé du Modèle de Régression",
    pn.pane.Markdown(model.summary().as_text())
)

dashboard.servable()

def filter_vif(X, threshold=10):
    while True:
        vif_data = calculate_vif(X)
        max_vif = vif_data["VIF"].max()
        if max_vif > threshold:
            # Supprimer la variable avec le VIF le plus élevé
            var_to_remove = vif_data.loc[vif_data["VIF"].idxmax(), "Variable"]
            print(f"Suppression de {var_to_remove} avec VIF={max_vif:.2f}")
            X = X.drop(columns=[var_to_remove])
        else:
            break
    return X

X_filtered = filter_vif(X_scaled, threshold=10)

from sklearn.feature_selection import SelectKBest, f_regression

selector = SelectKBest(score_func=f_regression, k=10)  # Sélectionner les 10 meilleures variables
X_selected = selector.fit_transform(X_scaled, y)
selected_columns = X_scaled.columns[selector.get_support()]
print("Variables sélectionnées :", selected_columns)
X_scaled = X_scaled[selected_columns]  # Garder uniquement les meilleures variables

Variables sélectionnées : Index(['education-num', 'sex_Male', 'income_>50K',
       'marital-status_Never-married', 'workclass_Private',
       'workclass_Self-emp-inc', 'relationship_Own-child',
       'occupation_Exec-managerial', 'occupation_Other-service',
       'marital-status_Married-civ-spouse'],
      dtype='object')

from sklearn.linear_model import LassoCV

lasso = LassoCV(cv=5).fit(X_scaled, y)
selected_features = X_scaled.columns[lasso.coef_ != 0]
print("Variables sélectionnées après Lasso :", selected_features)
X_scaled = X_scaled[selected_features]

Variables sélectionnées après Lasso : Index(['education-num', 'sex_Male', 'income_>50K',
       'marital-status_Never-married', 'workclass_Private',
       'workclass_Self-emp-inc', 'relationship_Own-child',
       'occupation_Exec-managerial', 'occupation_Other-service',
       'marital-status_Married-civ-spouse'],
      dtype='object')

from sklearn.linear_model import RidgeCV

ridge = RidgeCV(alphas=np.logspace(-6, 6, 13), cv=5).fit(X_scaled, y)
print("Score R² avec Ridge :", ridge.score(X_scaled, y))

Score R² avec Ridge : 0.14749945499730865

# Régression avec les nouvelles variables sélectionnées
X_scaled = sm.add_constant(X_scaled)
X_train, X_test, y_train, y_test = train_test_split(X_scaled, y, test_size=0.2, random_state=42)

model = sm.OLS(y_train, X_train).fit()
y_pred = model.predict(X_test)

# Comparaison des métriques
r2_new = r2_score(y_test, y_pred)
rmse_new = np.sqrt(mean_squared_error(y_test, y_pred))
print(f"R² après sélection des variables : {r2_new:.4f}")
print(f"RMSE après sélection des variables : {rmse_new:.4f}")

R² après sélection des variables : 0.1413
RMSE après sélection des variables : 11.5005

import ssl
import pandas as pd
import panel as pn
import numpy as np
import statsmodels.api as sm
import seaborn as sns
import matplotlib.pyplot as plt
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.metrics import mean_squared_error, r2_score
from statsmodels.stats.outliers_influence import variance_inflation_factor
from sklearn.ensemble import RandomForestRegressor

# Activer Panel avec Tabulator
pn.extension('tabulator')

# Désactiver la vérification SSL
ssl._create_default_https_context = ssl._create_unverified_context

# URL du dataset
url_adult = "https://archive.ics.uci.edu/ml/machine-learning-databases/adult/adult.data"

# Noms des colonnes
column_names_adult = [
    "age", "workclass", "fnlwgt", "education", "education-num", "marital-status",
    "occupation", "relationship", "race", "sex", "capital-gain", "capital-loss",
    "hours-per-week", "native-country", "income"
]

# Chargement des données avec mise en cache
if 'data_adult' not in pn.state.cache.keys():
    df_adult = pd.read_csv(
        url_adult, names=column_names_adult, sep=",", header=None, skipinitialspace=True
    )

    # Suppression des espaces superflus dans les colonnes textuelles
    str_cols = df_adult.select_dtypes(object).columns
    df_adult[str_cols] = df_adult[str_cols].apply(lambda x: x.str.strip())

    # Stockage en cache
    pn.state.cache['data_adult'] = df_adult.copy()
else:
    df_adult = pn.state.cache['data_adult']

# Détection des valeurs "?"
def impute_mode(df):
    for col in df.columns:
        if df[col].dtype == "object":
            mode = df[col].mode()[0]
            df[col] = df[col].replace("?", mode)
    return df

# Application de la meilleure méthode d'imputation (par mode ici)
df_best = impute_mode(df_adult.copy())

# Suppression de la colonne inutile "fnlwgt"
df_best.drop(columns=["fnlwgt"], inplace=True)

# Encodage one-hot des variables catégoriques
df_best = pd.get_dummies(df_best, drop_first=True)

# Sélection des variables indépendantes et dépendantes
X = df_best.drop(columns=["hours-per-week"])
y = df_best["hours-per-week"]

# Identification des variables les plus influentes avec Random Forest
rf_model = RandomForestRegressor(n_estimators=100, random_state=42)
rf_model.fit(X, y)
feature_importances = pd.DataFrame({
    'Variable': X.columns,
    'Importance': rf_model.feature_importances_
}).sort_values(by='Importance', ascending=False)

# Sélection des variables les plus influentes (seuil > 0.01 pour éviter le bruit)
important_features = feature_importances[feature_importances["Importance"] > 0.01]["Variable"].tolist()
X = X[important_features]

# Suppression des variables non significatives et corrélées (p-value > 0.05 ou VIF > 5)
def filter_features(X, model):
    p_values = model.pvalues
    significant_vars = p_values[p_values < 0.05].index.tolist()
    
    vif_data = calculate_vif(X)
    low_vif_vars = vif_data[vif_data["VIF"] < 5]["Variable"].tolist()
    
    selected_vars = list(set(significant_vars) & set(low_vif_vars))
    return X[selected_vars]

# Standardisation des variables
scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)
X_scaled = pd.DataFrame(X_scaled, columns=X.columns)

# Ajout de la constante pour le modèle de régression multiple
X_scaled = sm.add_constant(X_scaled)

# Séparation en ensemble d'entraînement et de test
X_train, X_test, y_train, y_test = train_test_split(X_scaled, y, test_size=0.2, random_state=42)

# Modèle de régression multiple
model = sm.OLS(y_train, X_train).fit()
X_filtered = filter_features(X_train, model)
model_refined = sm.OLS(y_train, X_filtered).fit()
y_pred = model_refined.predict(X_test[X_filtered.columns])

# Évaluation du modèle
r2 = r2_score(y_test, y_pred)
rmse = np.sqrt(mean_squared_error(y_test, y_pred))
adj_r2 = model_refined.rsquared_adj

# Vérification des hypothèses de régression
# 1. Multicolinéarité (Variance Inflation Factor - VIF)
def calculate_vif(X):
    vif_data = pd.DataFrame()
    vif_data["Variable"] = X.columns
    vif_values = []
    for i in range(X.shape[1]):
        try:
            vif = variance_inflation_factor(X.values, i)
            vif_values.append(vif)
        except:
            vif_values.append(np.nan)
    vif_data["VIF"] = vif_values
    return vif_data.dropna()

vif_results = calculate_vif(X_filtered)

# 2. Normalité des résidus
residuals = y_test - y_pred

# 3. Homoscédasticité (test visuel avec les résidus)
def plot_residuals(y_test, y_pred, residuals):
    fig, axes = plt.subplots(1, 2, figsize=(12, 5))
    sns.histplot(residuals, kde=True, ax=axes[0], bins=50)
    axes[0].set_title("Distribution des Résidus")
    
    sns.scatterplot(x=y_pred, y=residuals, ax=axes[1], alpha=0.5)
    axes[1].axhline(y=0, color='red', linestyle='--')
    axes[1].set_xlabel("Valeurs Prédites")
    axes[1].set_ylabel("Résidus")
    axes[1].set_title("Graphique des Résidus")
    
    plt.show()

plot_residuals(y_test, y_pred, residuals)

# Affichage des résultats
dashboard = pn.Column(
    "##  Régression Multiple : Prédiction du Temps de Travail Hebdomadaire",
    f"###  R² ajusté : {adj_r2:.4f}",
    f"###  RMSE : {rmse:.4f}",
    "##  Variables les plus influentes",
    pn.widgets.Tabulator(feature_importances, pagination='remote', page_size=10, configuration={"layout": "fitDataStretch"}),
    "##  Analyse de la Multicolinéarité (VIF)",
    pn.widgets.Tabulator(vif_results, pagination='remote', page_size=10, configuration={"layout": "fitDataStretch"}),
    "##  Résumé du Modèle de Régression",
    pn.pane.Markdown(model_refined.summary().as_text())
)

dashboard.servable()

import ssl
import pandas as pd
import panel as pn
import numpy as np
import statsmodels.api as sm
import seaborn as sns
import matplotlib.pyplot as plt
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.metrics import mean_squared_error, r2_score
from statsmodels.stats.outliers_influence import variance_inflation_factor
from sklearn.ensemble import RandomForestRegressor

# Activer Panel avec Tabulator
pn.extension('tabulator')

# Désactiver la vérification SSL
ssl._create_default_https_context = ssl._create_unverified_context

# URL du dataset
url_adult = "https://archive.ics.uci.edu/ml/machine-learning-databases/adult/adult.data"

# Noms des colonnes
column_names_adult = [
    "age", "workclass", "fnlwgt", "education", "education-num", "marital-status",
    "occupation", "relationship", "race", "sex", "capital-gain", "capital-loss",
    "hours-per-week", "native-country", "income"
]

# Chargement des données avec mise en cache
if 'data_adult' not in pn.state.cache.keys():
    df_adult = pd.read_csv(
        url_adult, names=column_names_adult, sep=",", header=None, skipinitialspace=True
    )

    # Suppression des espaces superflus dans les colonnes textuelles
    str_cols = df_adult.select_dtypes(object).columns
    df_adult[str_cols] = df_adult[str_cols].apply(lambda x: x.str.strip())

    # Stockage en cache
    pn.state.cache['data_adult'] = df_adult.copy()
else:
    df_adult = pn.state.cache['data_adult']

# Détection des valeurs "?"
def impute_mode(df):
    for col in df.columns:
        if df[col].dtype == "object":
            mode = df[col].mode()[0]
            df[col] = df[col].replace("?", mode)
    return df

# Application de la meilleure méthode d'imputation (par mode ici)
df_best = impute_mode(df_adult.copy())

# Suppression de la colonne inutile "fnlwgt"
df_best.drop(columns=["fnlwgt"], inplace=True)

# Encodage one-hot des variables catégoriques
df_best = pd.get_dummies(df_best, drop_first=True)

# Sélection des variables indépendantes et dépendantes
X = df_best.drop(columns=["hours-per-week"])
y = df_best["hours-per-week"]

# Identification des variables les plus influentes avec Random Forest
rf_model = RandomForestRegressor(n_estimators=100, random_state=42)
rf_model.fit(X, y)
feature_importances = pd.DataFrame({
    'Variable': X.columns,
    'Importance': rf_model.feature_importances_
}).sort_values(by='Importance', ascending=False)

# Sélection des variables les plus influentes (seuil > 0.01 pour éviter le bruit)
important_features = feature_importances[feature_importances["Importance"] > 0.01]["Variable"].tolist()
X = X[important_features]

# Suppression des variables non significatives et corrélées (p-value > 0.05 ou VIF > 5)
def filter_features(X, model):
    p_values = model.pvalues
    significant_vars = p_values[p_values < 0.05].index.tolist()
    
    vif_data = calculate_vif(X)
    low_vif_vars = vif_data[vif_data["VIF"] < 5]["Variable"].tolist()
    
    selected_vars = list(set(significant_vars) & set(low_vif_vars))
    return X[selected_vars]

# Standardisation des variables
scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)
X_scaled = pd.DataFrame(X_scaled, columns=X.columns)

# Ajout de la constante pour le modèle de régression multiple
X_scaled = sm.add_constant(X_scaled)

# Séparation en ensemble d'entraînement et de test
X_train, X_test, y_train, y_test = train_test_split(X_scaled, y, test_size=0.2, random_state=42)

# Modèle de régression multiple
model = sm.OLS(y_train, X_train).fit()
X_filtered = filter_features(X_train, model)
model_refined = sm.OLS(y_train, X_filtered).fit()
y_pred = model_refined.predict(X_test[X_filtered.columns])

# Évaluation du modèle
r2 = r2_score(y_test, y_pred)
rmse = np.sqrt(mean_squared_error(y_test, y_pred))
adj_r2 = model_refined.rsquared_adj

# Vérification des hypothèses de régression
# 1. Multicolinéarité (Variance Inflation Factor - VIF)
def calculate_vif(X):
    vif_data = pd.DataFrame()
    vif_data["Variable"] = X.columns
    vif_values = []
    for i in range(X.shape[1]):
        try:
            vif = variance_inflation_factor(X.values, i)
            vif_values.append(vif)
        except:
            vif_values.append(np.nan)
    vif_data["VIF"] = vif_values
    return vif_data.dropna()

vif_results = calculate_vif(X_filtered)

# 2. Normalité des résidus
residuals = y_test - y_pred

# 3. Homoscédasticité (test visuel avec les résidus)
def plot_residuals(y_test, y_pred, residuals):
    fig, axes = plt.subplots(1, 3, figsize=(18, 5))
    sns.histplot(residuals, kde=True, ax=axes[0], bins=50)
    axes[0].set_title("Distribution des Résidus")
    
    sns.scatterplot(x=y_pred, y=residuals, ax=axes[1], alpha=0.5)
    axes[1].axhline(y=0, color='red', linestyle='--')
    axes[1].set_xlabel("Valeurs Prédites")
    axes[1].set_ylabel("Résidus")
    axes[1].set_title("Graphique des Résidus")
    
    sns.histplot(y, kde=True, ax=axes[2], bins=50)
    axes[2].set_title("Distribution du Temps de Travail Hebdomadaire")
    axes[2].set_xlabel("Heures par semaine")
    
    plt.show()

plot_residuals(y_test, y_pred, residuals)

# Affichage des résultats
dashboard = pn.Column(
    "## 📋 Régression Multiple : Prédiction du Temps de Travail Hebdomadaire",
    f"### 🔍 R² ajusté : {adj_r2:.4f}",
    f"### 📉 RMSE : {rmse:.4f}",
    "## 📊 Variables les plus influentes",
    pn.widgets.Tabulator(feature_importances, pagination='remote', page_size=10, configuration={"layout": "fitDataStretch"}),
    "## 📊 Analyse de la Multicolinéarité (VIF)",
    pn.widgets.Tabulator(vif_results, pagination='remote', page_size=10, configuration={"layout": "fitDataStretch"}),
    "## 📈 Résumé du Modèle de Régression",
    pn.pane.Markdown(model_refined.summary().as_text())
)

dashboard.servable()

import ssl
import pandas as pd
import panel as pn
import numpy as np
import statsmodels.api as sm
import seaborn as sns
import matplotlib.pyplot as plt
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.metrics import mean_squared_error, r2_score
from statsmodels.stats.outliers_influence import variance_inflation_factor
from sklearn.ensemble import RandomForestRegressor
from scipy import stats

import warnings
warnings.simplefilter(action='ignore', category=FutureWarning)


# Activer Panel avec Tabulator
pn.extension('tabulator')

# Désactiver la vérification SSL
ssl._create_default_https_context = ssl._create_unverified_context

# URL du dataset
url_adult = "https://archive.ics.uci.edu/ml/machine-learning-databases/adult/adult.data"

# Noms des colonnes
column_names_adult = [
    "age", "workclass", "fnlwgt", "education", "education-num", "marital-status",
    "occupation", "relationship", "race", "sex", "capital-gain", "capital-loss",
    "hours-per-week", "native-country", "income"
]

# Chargement des données avec mise en cache
if 'data_adult' not in pn.state.cache.keys():
    df_adult = pd.read_csv(
        url_adult, names=column_names_adult, sep=",", header=None, skipinitialspace=True
    )

    # Suppression des espaces superflus dans les colonnes textuelles
    str_cols = df_adult.select_dtypes(object).columns
    df_adult[str_cols] = df_adult[str_cols].apply(lambda x: x.str.strip())

    # Stockage en cache
    pn.state.cache['data_adult'] = df_adult.copy()
else:
    df_adult = pn.state.cache['data_adult']

# Détection des valeurs "?"
def impute_mode(df):
    for col in df.columns:
        if df[col].dtype == "object":
            mode = df[col].mode()[0]
            df[col] = df[col].replace("?", mode)
    return df

# Application de la meilleure méthode d'imputation (par mode ici)
df_best = impute_mode(df_adult.copy())

# Suppression de la colonne inutile "fnlwgt"
df_best.drop(columns=["fnlwgt"], inplace=True)

# Encodage one-hot des variables catégoriques
df_best = pd.get_dummies(df_best, drop_first=True)

# Sélection des variables indépendantes et dépendantes
X = df_best.drop(columns=["hours-per-week"])
y = df_best["hours-per-week"]

# Identification des variables les plus influentes avec Random Forest
rf_model = RandomForestRegressor(n_estimators=100, random_state=42)
rf_model.fit(X, y)
feature_importances = pd.DataFrame({
    'Variable': X.columns,
    'Importance': rf_model.feature_importances_
}).sort_values(by='Importance', ascending=False)

# Sélection des variables les plus influentes (seuil > 0.01 pour éviter le bruit)
important_features = feature_importances[feature_importances["Importance"] > 0.01]["Variable"].tolist()
X = X[important_features]

# Suppression des variables non significatives et corrélées (p-value > 0.05 ou VIF > 5)
def filter_features(X, model):
    p_values = model.pvalues
    significant_vars = p_values[p_values < 0.05].index.tolist()
    
    vif_data = calculate_vif(X)
    low_vif_vars = vif_data[vif_data["VIF"] < 5]["Variable"].tolist()
    
    selected_vars = list(set(significant_vars) & set(low_vif_vars))
    return X[selected_vars]

# Standardisation des variables
scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)
X_scaled = pd.DataFrame(X_scaled, columns=X.columns)

# Ajout de la constante pour le modèle de régression multiple
X_scaled = sm.add_constant(X_scaled)

# Séparation en ensemble d'entraînement et de test
X_train, X_test, y_train, y_test = train_test_split(X_scaled, y, test_size=0.2, random_state=42)

# Modèle de régression multiple
model = sm.OLS(y_train, X_train).fit()
X_filtered = filter_features(X_train, model)
model_refined = sm.OLS(y_train, X_filtered).fit()
y_pred = model_refined.predict(X_test[X_filtered.columns])

# Évaluation du modèle
r2 = r2_score(y_test, y_pred)
rmse = np.sqrt(mean_squared_error(y_test, y_pred))
adj_r2 = model_refined.rsquared_adj

# Vérification des hypothèses de régression
# 1. Multicolinéarité (Variance Inflation Factor - VIF)
def calculate_vif(X):
    vif_data = pd.DataFrame()
    vif_data["Variable"] = X.columns
    vif_values = []
    for i in range(X.shape[1]):
        try:
            vif = variance_inflation_factor(X.values, i)
            vif_values.append(vif)
        except:
            vif_values.append(np.nan)
    vif_data["VIF"] = vif_values
    return vif_data.dropna()

vif_results = calculate_vif(X_filtered)

# 2. Normalité des résidus
residuals = y_test - y_pred

# 3. Homoscédasticité (test visuel avec les résidus)
def plot_residuals(y_test, y_pred, residuals):
    fig, axes = plt.subplots(1, 3, figsize=(18, 5))
    sns.histplot(residuals, kde=True, ax=axes[0], bins=50)
    axes[0].set_title("Distribution des Résidus")
    
    sns.scatterplot(x=y_pred, y=residuals, ax=axes[1], alpha=0.5)
    axes[1].axhline(y=0, color='red', linestyle='--')
    axes[1].set_xlabel("Valeurs Prédites")
    axes[1].set_ylabel("Résidus")
    axes[1].set_title("Graphique des Résidus")
    
    sns.histplot(y, kde=True, ax=axes[2], bins=50)
    axes[2].set_title("Distribution du Temps de Travail Hebdomadaire")
    axes[2].set_xlabel("Heures par semaine")
    
    plt.show()

# 4. QQ-plot pour vérifier la normalité des résidus
def plot_qq(residuals):
    plt.figure(figsize=(6, 6))
    stats.probplot(residuals, dist="norm", plot=plt)
    plt.title("QQ-plot des Résidus")
    plt.show()

# 5. Graphique des coefficients du modèle
def plot_coefficients(model):
    coef_df = pd.DataFrame({
        'Variable': model.params.index,
        'Coefficient': model.params.values
    })
    coef_df = coef_df[coef_df['Variable'] != 'const']  # Exclure la constante
    coef_df = coef_df.sort_values(by='Coefficient', ascending=False)
    
    plt.figure(figsize=(10, 6))
    sns.barplot(x='Coefficient', y='Variable', data=coef_df, palette='viridis')
    
    plt.title("Coefficients du Modèle de Régression")
    plt.xlabel("Coefficient")
    plt.ylabel("Variable")
    plt.show()

# 6. Matrice de corrélation
def plot_correlation_matrix(X):
    plt.figure(figsize=(10, 8))
    sns.heatmap(X.corr(), annot=True, cmap='coolwarm', fmt='.2f')
    plt.title("Matrice de Corrélation")
    plt.show()

# Affichage des graphiques
plot_residuals(y_test, y_pred, residuals)
plot_qq(residuals)
plot_coefficients(model_refined)
plot_correlation_matrix(X_filtered)

# Affichage des résultats
dashboard = pn.Column(
    "## 📋 Régression Multiple : Prédiction du Temps de Travail Hebdomadaire",
    f"### 🔍 R² ajusté : {adj_r2:.4f}",
    f"### 📉 RMSE : {rmse:.4f}",
    "## 📊 Variables les plus influentes",
    pn.widgets.Tabulator(feature_importances, pagination='remote', page_size=10, configuration={"layout": "fitDataStretch"}),
    "## 📊 Analyse de la Multicolinéarité (VIF)",
    pn.widgets.Tabulator(vif_results, pagination='remote', page_size=10, configuration={"layout": "fitDataStretch"}),
    "## 📈 Résumé du Modèle de Régression",
    pn.pane.Markdown(model_refined.summary().as_text())
)

dashboard.servable()

import panel as pn
import hvplot.pandas
import ssl

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
from sklearn.preprocessing import StandardScaler, OneHotEncoder
from sklearn.impute import SimpleImputer
from sklearn.compose import ColumnTransformer
from sklearn.pipeline import Pipeline
from sklearn.decomposition import PCA

# Activer Panel avec Tabulator
pn.extension('tabulator')

# Désactiver la vérification SSL
ssl._create_default_https_context = ssl._create_unverified_context

# URL du dataset
url_adult = "https://archive.ics.uci.edu/ml/machine-learning-databases/adult/adult.data"

# Noms des colonnes
column_names_adult = [
    "age", "workclass", "fnlwgt", "education", "education-num", "marital-status",
    "occupation", "relationship", "race", "sex", "capital-gain", "capital-loss",
    "hours-per-week", "native-country", "income"
]

# Chargement des données avec mise en cache
if 'data_adult' not in pn.state.cache.keys():
    df_adult = pd.read_csv(
        url_adult, names=column_names_adult, sep=",", header=None, skipinitialspace=True
    )

    # Suppression des espaces superflus dans les colonnes textuelles
    str_cols = df_adult.select_dtypes(object).columns
    df_adult[str_cols] = df_adult[str_cols].apply(lambda x: x.str.strip())

    # Stockage en cache
    pn.state.cache['data_adult'] = df_adult.copy()
else:
    df_adult = pn.state.cache['data_adult']

# Détection des valeurs "?"
missing_mask = df_adult == "?"

# Création d'une copie du DataFrame pour affichage HTML
df_display = df_adult.copy()

# Remplacement des valeurs "?" par une version colorée en HTML
for col in df_adult.columns:
    df_display[col] = df_adult[col].apply(
        lambda x: f'<span style="background-color:red; color:white; font-weight:bold; padding:3px;">{x}</span>' 
        if x == "?" else x
    )

# Récapitulatif des valeurs "?" par colonne
missing_counts = missing_mask.sum().reset_index()
missing_counts.columns = ["Variable", "Nombre de valeurs '?'"]

# Mise en couleur des cellules ayant des valeurs manquantes
for col in missing_counts.columns:
    missing_counts[col] = missing_counts[col].astype(str)

missing_counts["Nombre de valeurs '?'"] = missing_counts["Nombre de valeurs '?'"].apply(
    lambda x: f'<span style="background-color:red; color:white; font-weight:bold; padding:3px;">{x}</span>'
    if x != "0" else x
)

# Création du tableau interactif avec mise en rouge des valeurs non nulles
missing_table = pn.widgets.Tabulator(
    missing_counts,
    pagination='remote', 
    page_size=20,
    formatters={col: {"type": "html"} for col in missing_counts.columns},  # Activation HTML
    configuration={"layout": "fitDataStretch"}
)

# Configuration du tableau principal avec formatage HTML
table = pn.widgets.Tabulator(
    df_display, 
    pagination='remote', 
    page_size=10, 
    formatters={col: {"type": "html"} for col in df_adult.columns},  # Activer l'affichage HTML
    configuration={"layout": "fitDataStretch"}
)

# Affichage interactif du tableau avec le résumé des valeurs manquantes
dashboard = pn.Column(
    "## 📋 Tableau des données avec valeurs `?` mises en rouge",
    table,
    "# Dataset Adult - Valeurs manquantes",
    "🔴 **Toutes les cellules contenant `?` sont colorées en rouge.**",
    "## Nombre de valeurs `?` par colonne (les valeurs non nulles sont mises en rouge)",
    "## variables catégorielles contenant des valeurs manquantes sont: workclass, occupation, native-country" ,
    missing_table,
    
)

dashboard.servable()

# Remplacer les valeurs "?" par NaN
df_adult.replace("?", np.nan, inplace=True)

# Séparer les variables numériques et catégorielles
numerical_cols = df_adult.select_dtypes(include=['int64', 'float64']).columns
categorical_cols = df_adult.select_dtypes(include=['object']).columns

# Créer un pipeline pour les variables numériques
numerical_pipeline = Pipeline([
    ('imputer', SimpleImputer(strategy='mean')),  # Imputation des valeurs manquantes par la moyenne
    ('scaler', StandardScaler())  # Normalisation des données
])

# Créer un pipeline pour les variables catégorielles
categorical_pipeline = Pipeline([
    ('imputer', SimpleImputer(strategy='most_frequent')),  # Imputation des valeurs manquantes par le mode
    ('onehot', OneHotEncoder(handle_unknown='ignore'))  # Encodage one-hot
])

# Combiner les pipelines dans un ColumnTransformer
preprocessor = ColumnTransformer([
    ('num', numerical_pipeline, numerical_cols),
    ('cat', categorical_pipeline, categorical_cols)
])

# Appliquer le prétraitement
df_preprocessed = preprocessor.fit_transform(df_adult)

# Instancier l'ACP
pca = PCA(n_components=2)  # Vous pouvez ajuster le nombre de composantes principales

# Appliquer l'ACP
df_pca = pca.fit_transform(df_preprocessed)

# Convertir le résultat en DataFrame pour une meilleure visualisation
df_pca = pd.DataFrame(df_pca, columns=['PC1', 'PC2'])

# Visualiser les deux premières composantes principales
pca_plot = df_pca.hvplot.scatter(
    x='PC1', 
    y='PC2', 
    title='ACP des données Adult',
    xlabel='Première Composante Principale (PC1)',
    ylabel='Deuxième Composante Principale (PC2)'
)

# Afficher le plot
pn.panel(pca_plot).servable()

# Variance expliquée par chaque composante
explained_variance = pca.explained_variance_ratio_

# Afficher la variance expliquée
print(f"Variance expliquée par chaque composante : {explained_variance}")

# Contributions des variables originales aux composantes principales
loadings = pca.components_

# Convertir en DataFrame pour une meilleure visualisation
loadings_df = pd.DataFrame(loadings, columns=preprocessor.get_feature_names_out(), index=['PC1', 'PC2'])

# Afficher les contributions
display(loadings_df)

Variance expliquée par chaque composante : [0.1569525  0.10479365]

# Appliquer le prétraitement
X_processed = preprocessor.fit_transform(df_adult)

# 3. Application de l'ACP
# Instancier l'ACP
pca = PCA(n_components=None)  # On conserve toutes les composantes pour l'analyse
X_pca = pca.fit_transform(X_processed)

# Variance expliquée par chaque composante
explained_variance = pca.explained_variance_ratio_

# Convertir en DataFrame pour une meilleure visualisation
explained_variance_df = pd.DataFrame({
    'Composante': range(1, len(explained_variance) + 1),
    'Variance expliquée': explained_variance,
    'Variance cumulée': np.cumsum(explained_variance)
})

# Contributions des variables originales aux composantes principales
loadings = pca.components_

# Convertir en DataFrame pour une meilleure visualisation
loadings_df = pd.DataFrame(loadings[:2], columns=preprocessor.get_feature_names_out(), index=['PC1', 'PC2'])

# 4. Affichage des résultats avec Panel

# Widget pour afficher la variance expliquée
variance_explained_pane = pn.pane.DataFrame(
    explained_variance_df,
    index=False,
    sizing_mode='stretch_width',
    name='Variance expliquée'
)

# Widget pour afficher les contributions des variables
loadings_pane = pn.pane.DataFrame(
    loadings_df,
    sizing_mode='stretch_width',
    name='Contributions des variables'
)

# Créer un tableau de bord interactif avec Panel
dashboard = pn.Column(
    "## Analyse en Composantes Principales (ACP) du jeu de données Adult",
    "### Variance expliquée par chaque composante",
    variance_explained_pane,
    "### Contributions des variables aux deux premières composantes principales",
    loadings_pane
)

# Afficher le tableau de bord
dashboard.servable()

# Ajouter le plot de l'ACP au tableau de bord
dashboard = pn.Column(
    "## 📋 Tableau des données avec valeurs `?` mises en rouge",
    table,
    "# Dataset Adult - Valeurs manquantes",
    "🔴 **Toutes les cellules contenant `?` sont colorées en rouge.**",
    "## Nombre de valeurs `?` par colonne (les valeurs non nulles sont mises en rouge)",
    "## variables catégorielles contenant des valeurs manquantes sont: workclass, occupation, native-country",
    missing_table,
    "## Analyse en Composantes Principales (ACP)",
    pca_plot
)

dashboard.servable()

# 1. Prétraitement des données
# Remplacer les valeurs "?" par NaN
df_adult.replace("?", np.nan, inplace=True)

# Supprimer les lignes avec des valeurs manquantes
df_adult = df_adult.dropna()

# Séparer les variables numériques et catégorielles
numeric_cols = ['age', 'fnlwgt', 'education-num', 'capital-gain', 'capital-loss', 'hours-per-week']
categorical_cols = ['workclass', 'education', 'marital-status', 'occupation', 'relationship', 'race', 'sex', 'native-country']

df_num = df_adult[numeric_cols]
df_cat = df_adult[categorical_cols]

# 2. Encodage des variables catégorielles
# Utilisation de OneHotEncoder pour encoder les variables catégorielles
cat_pipeline = Pipeline([
    ('imputer', SimpleImputer(strategy='most_frequent')),  # Imputation des valeurs manquantes
    ('onehot', OneHotEncoder(handle_unknown='ignore', drop='first'))  # Encodage One-Hot
])

# Combiner les pipelines pour les variables numériques et catégorielles
preprocessor = ColumnTransformer([
    ('num', StandardScaler(), numeric_cols),  # Normalisation des variables numériques
    ('cat', cat_pipeline, categorical_cols)  # Encodage des variables catégorielles
])

# Appliquer le prétraitement
X_processed = preprocessor.fit_transform(df_adult)

# 3. Application de l'ACP
# Instancier l'ACP
pca = PCA(n_components=None)  # On conserve toutes les composantes pour l'analyse
X_pca = pca.fit_transform(X_processed)

# 4. Visualisation des résultats
# Scree plot (variance expliquée par composante)
explained_variance = pca.explained_variance_ratio_
cumulative_variance = np.cumsum(explained_variance)

plt.figure(figsize=(10, 6))
plt.bar(range(1, len(explained_variance) + 1), explained_variance, alpha=0.6, label='Variance expliquée par composante')
plt.plot(range(1, len(cumulative_variance) + 1), cumulative_variance, marker='o', label='Variance cumulée')
plt.xlabel('Nombre de composantes principales')
plt.ylabel('Variance expliquée')
plt.title('Scree plot - Variance expliquée par composante')
plt.legend()
plt.grid(True)
plt.show()

# Scree Plot (Variance expliquée par composante principale)
plt.figure(figsize=(10, 5))
plt.plot(range(1, len(explained_var) + 1), cumulative_var, marker='o', linestyle='--', color='b')
plt.xlabel("Nombre de Composantes Principales")
plt.ylabel("Variance Cumulative Expliquée")
plt.title("Scree Plot - Variance Expliquée")
plt.grid(True)
plt.show()

# Variance expliquée par chaque composante
explained_variance = pca.explained_variance_ratio_
cumulative_variance = np.cumsum(explained_variance)

# 4. Graphique de la méthode du coude
plt.figure(figsize=(10, 6))
plt.plot(range(1, len(explained_variance) + 1), explained_variance, marker='o', linestyle='-', color='b', label='Variance expliquée par composante')
plt.plot(range(1, len(cumulative_variance) + 1), cumulative_variance, marker='o', linestyle='-', color='r', label='Variance cumulée')
plt.xlabel('Nombre de composantes principales')
plt.ylabel('Variance expliquée')
plt.title('Méthode du Coude - Variance expliquée par composante')
plt.legend(loc='best')
plt.grid(True)
plt.show()

# Projection des individus sur les deux premières composantes principales
df_pca = pd.DataFrame(X_pca[:, :2], columns=["PC1", "PC2"])

plt.figure(figsize=(10, 6))
sns.scatterplot(x=df_pca["PC1"], y=df_pca["PC2"], alpha=0.5)
plt.xlabel("Première Composante Principale (PC1)")
plt.ylabel("Deuxième Composante Principale (PC2)")
plt.title("Projection des individus sur le plan des deux premières composantes")
plt.grid(True)
plt.show()

# Projection des individus sur les deux premières composantes principales
plt.figure(figsize=(10, 6))
sns.scatterplot(x=X_pca[:, 0], y=X_pca[:, 1], hue=df_adult['income'], palette='viridis', alpha=0.6)
plt.xlabel('Première composante principale (PC1)')
plt.ylabel('Deuxième composante principale (PC2)')
plt.title('Projection des individus sur PC1 et PC2')
plt.legend(title='Income')
plt.grid(True)
plt.show()

# Importance des variables dans les composantes principales
# Récupérer les loadings (coefficients des variables dans les composantes)
loadings = pca.components_

# Créer un DataFrame pour visualiser les contributions des variables
loadings_df = pd.DataFrame(loadings[:2], columns=preprocessor.get_feature_names_out(), index=['PC1', 'PC2'])

# Visualiser les contributions des variables à PC1
plt.figure(figsize=(12, 6))
sns.barplot(x=loadings_df.columns, y=loadings_df.loc['PC1'])
plt.xticks(rotation=90)
plt.xlabel('Variables')
plt.ylabel('Contribution à PC1')
plt.title('Contributions des variables à la première composante principale (PC1)')
plt.grid(True)
plt.show()

# Importance des variables dans la première composante principale (PC1)
plt.figure(figsize=(12, 6))
sns.barplot(x=np.arange(len(pca.components_[0])), y=pca.components_[0])
plt.xlabel("Variables")
plt.ylabel("Poids dans la première composante")
plt.title("Importance des variables dans la première composante principale")
plt.xticks(ticks=np.arange(len(df_processed.columns)), labels=df_processed.columns, rotation=90)
plt.show()

# Visualiser les contributions des variables à PC2
plt.figure(figsize=(12, 6))
sns.barplot(x=loadings_df.columns, y=loadings_df.loc['PC2'])
plt.xticks(rotation=90)
plt.xlabel('Variables')
plt.ylabel('Contribution à PC2')
plt.title('Contributions des variables à la deuxième composante principale (PC2)')
plt.grid(True)
plt.show()

import panel as pn
import hvplot.pandas
import ssl

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
from sklearn.preprocessing import StandardScaler, OneHotEncoder
from sklearn.impute import SimpleImputer
from sklearn.compose import ColumnTransformer
from sklearn.pipeline import Pipeline
from sklearn.decomposition import PCA

# Activer Panel avec Tabulator
pn.extension('tabulator')

# Désactiver la vérification SSL
ssl._create_default_https_context = ssl._create_unverified_context

# URL du dataset
url_adult = "https://archive.ics.uci.edu/ml/machine-learning-databases/adult/adult.data"

# Noms des colonnes
column_names_adult = [
    "age", "workclass", "fnlwgt", "education", "education-num", "marital-status",
    "occupation", "relationship", "race", "sex", "capital-gain", "capital-loss",
    "hours-per-week", "native-country", "income"
]

# Chargement des données avec mise en cache
if 'data_adult' not in pn.state.cache.keys():
    df_adult = pd.read_csv(
        url_adult, names=column_names_adult, sep=",", header=None, skipinitialspace=True
    )

    # Suppression des espaces superflus dans les colonnes textuelles
    str_cols = df_adult.select_dtypes(object).columns
    df_adult[str_cols] = df_adult[str_cols].apply(lambda x: x.str.strip())

    # Stockage en cache
    pn.state.cache['data_adult'] = df_adult.copy()
else:
    df_adult = pn.state.cache['data_adult']

# Détection des valeurs "?"
missing_mask = df_adult == "?"

# Création d'une copie du DataFrame pour affichage HTML
df_display = df_adult.copy()

# Remplacement des valeurs "?" par une version colorée en HTML
for col in df_adult.columns:
    df_display[col] = df_adult[col].apply(
        lambda x: f'<span style="background-color:red; color:white; font-weight:bold; padding:3px;">{x}</span>' 
        if x == "?" else x
    )

# Récapitulatif des valeurs "?" par colonne
missing_counts = missing_mask.sum().reset_index()
missing_counts.columns = ["Variable", "Nombre de valeurs '?'"]

# Mise en couleur des cellules ayant des valeurs manquantes
for col in missing_counts.columns:
    missing_counts[col] = missing_counts[col].astype(str)

missing_counts["Nombre de valeurs '?'"] = missing_counts["Nombre de valeurs '?'"].apply(
    lambda x: f'<span style="background-color:red; color:white; font-weight:bold; padding:3px;">{x}</span>'
    if x != "0" else x
)

# Création du tableau interactif avec mise en rouge des valeurs non nulles
missing_table = pn.widgets.Tabulator(
    missing_counts,
    pagination='remote', 
    page_size=20,
    formatters={col: {"type": "html"} for col in missing_counts.columns},  # Activation HTML
    configuration={"layout": "fitDataStretch"}
)

# Configuration du tableau principal avec formatage HTML
table = pn.widgets.Tabulator(
    df_display, 
    pagination='remote', 
    page_size=10, 
    formatters={col: {"type": "html"} for col in df_adult.columns},  # Activer l'affichage HTML
    configuration={"layout": "fitDataStretch"}
)

# Affichage interactif du tableau avec le résumé des valeurs manquantes
dashboard = pn.Column(
    "## 📋 Tableau des données avec valeurs `?` mises en rouge",
    table,
    "# Dataset Adult - Valeurs manquantes",
    "🔴 **Toutes les cellules contenant `?` sont colorées en rouge.**",
    "## Nombre de valeurs `?` par colonne (les valeurs non nulles sont mises en rouge)",
    "## variables catégorielles contenant des valeurs manquantes sont: workclass, occupation, native-country" ,
    missing_table,
    
)

dashboard.servable()

import pandas as pd
import numpy as np
import panel as pn
import hvplot.pandas
from sklearn.decomposition import TruncatedSVD
from sklearn.preprocessing import StandardScaler

# Activer l'extension Panel pour hvplot
pn.extension()

# Chargement des données
url_adult = "https://archive.ics.uci.edu/ml/machine-learning-databases/adult/adult.data"

# Noms des colonnes
column_names_adult = [
    "age", "workclass", "fnlwgt", "education", "education-num", "marital-status",
    "occupation", "relationship", "race", "sex", "capital-gain", "capital-loss",
    "hours-per-week", "native-country", "income"
]

df_adult = pd.read_csv(
    url_adult, names=column_names_adult, sep=",", header=None, skipinitialspace=True
)

# Suppression des espaces superflus dans les colonnes textuelles
str_cols = df_adult.select_dtypes(object).columns
df_adult[str_cols] = df_adult[str_cols].apply(lambda x: x.str.strip())

# Étape 1 : Construction de la Table de Contingence
contingency_table = pd.crosstab(df_adult['education'], df_adult['occupation'])

# Étape 2 : Réalisation de l'AFC (Analyse Factorielle des Correspondances)
# Normalisation de la table de contingence
table_scaled = contingency_table.div(contingency_table.sum(axis=1), axis=0)

# Application de la décomposition SVD pour extraire les axes principaux
svd = TruncatedSVD(n_components=2)
coord = svd.fit_transform(table_scaled)

# Création d'un DataFrame pour les coordonnées des modalités
df_afc = pd.DataFrame(coord, columns=['Dim1', 'Dim2'], index=contingency_table.index)

# Étape 3 : Visualisation avec hvplot
afc_plot = df_afc.hvplot.scatter(
    x='Dim1', y='Dim2', hover_cols=['index'], title="Biplot de l'AFC",
    xlabel='Dimension 1', ylabel='Dimension 2', color='red', size=100,
    height=500, width=800
)

# Étape 4 : Affichage de la table de contingence
contingency_table_pane = pn.pane.DataFrame(
    contingency_table,
    sizing_mode='stretch_width',
    name='Table de Contingence'
)

# Étape 5 : Création d'un tableau de bord interactif avec Panel
dashboard = pn.Column(
    "## Analyse Factorielle des Correspondances (AFC)",
    "### Table de Contingence : Education vs Occupation",
    contingency_table_pane,
    "### Biplot des modalités",
    afc_plot
)

# Affichage du tableau de bord
dashboard.servable()

# Suppression des espaces superflus dans les colonnes textuelles
str_cols = df_adult.select_dtypes(object).columns
df_adult[str_cols] = df_adult[str_cols].apply(lambda x: x.str.strip())

# Étape 1 : Construction de la table de contingence entre `education` et `occupation`
cont_table = pd.crosstab(df_adult['education'], df_adult['occupation'])

# Étape 2 : Réalisation de l'AFC
# Normalisation de la table de contingence
table_scaled = cont_table.div(cont_table.sum(axis=1), axis=0)

# Application de la décomposition SVD pour extraire les axes principaux
svd = TruncatedSVD(n_components=2)
coord_rows = svd.fit_transform(table_scaled)

# Coordonnées des modalités `education`
row_labels = cont_table.index.tolist()
df_education_coords = pd.DataFrame(coord_rows, columns=['Dim1', 'Dim2'], index=row_labels)
df_education_coords['Type'] = 'Education'

# Coordonnées des modalités `occupation`
coord_cols = svd.components_.T * svd.singular_values_
col_labels = cont_table.columns.tolist()
df_occupation_coords = pd.DataFrame(coord_cols, columns=['Dim1', 'Dim2'], index=col_labels)
df_occupation_coords['Type'] = 'Occupation'

# Fusion des données pour le biplot
df_afc = pd.concat([df_education_coords, df_occupation_coords])

# Étape 3 : Visualisation interactive avec hvplot
biplot = df_afc.hvplot.scatter(
    x='Dim1', y='Dim2', by='Type', hover_cols=['Type'],
    title="Biplot AFC : Education vs Occupation",
    legend='top_right',
    width=1000,  # Augmentation de la largeur du graphique
    height=600   # Augmentation de la hauteur du graphique
)

# Affichage du biplot interactif
biplot

# Calcul de l’inertie expliquée
singular_vals = svd.singular_values_
inertias = (singular_vals**2) / np.sum(singular_vals**2) * 100
inertia_df = pd.DataFrame({
    'Dimension': ['Dim1', 'Dim2'],
    'Inertie (%)': inertias[:2]
})

# Affichage du tableau de l'inertie expliquée
print("\nInertie Expliquée par les Dimensions")
display(inertia_df)

Inertie Expliquée par les Dimensions

	workclass	occupation	native-country
0	State-gov	Adm-clerical	United-States
1	Self-emp-not-inc	Exec-managerial	Cuba
2	Private	Handlers-cleaners	Jamaica
3	Federal-gov	Prof-specialty	India
4	Local-gov	Other-service	?
5	?	Sales	Mexico
6	Self-emp-inc	Craft-repair	South
7	Without-pay	Transport-moving	Puerto-Rico
8	Never-worked	Farming-fishing	Honduras
9	NaN	Machine-op-inspct	England

Critère	Avant Optimisation	Après Optimisation	Évolution
R² ajusté	0.172	0.172	❌ Stable
F-statistic	236.4	319.2	✅ Augmenté
AIC (Akaike)	1.999e+05	1.999e+05	🔄 Stable
BIC (Bayesian)	2.001e+05	2.000e+05	✅ Légère baisse
Nb de variables	23	17	✅ Réduction
Durbin-Watson	1.979	1.979	🔄 Stable

	num__age	num__fnlwgt	num__education-num	num__capital-gain	num__capital-loss	num__hours-per-week	cat__workclass_Federal-gov	cat__workclass_Local-gov	cat__workclass_Never-worked	cat__workclass_Private	...	cat__native-country_Scotland	cat__native-country_South	cat__native-country_Taiwan	cat__native-country_Thailand	cat__native-country_Trinadad&Tobago	cat__native-country_United-States	cat__native-country_Vietnam	cat__native-country_Yugoslavia	cat__income_<=50K	cat__income_>50K
PC1	0.437945	-0.109365	0.401933	0.285027	0.203987	0.430861	0.008504	0.015640	-0.000236	-0.093350	...	0.000006	0.000403	0.000478	-0.000027	-0.000182	0.014986	-0.000628	0.000086	-0.205326	0.205326
PC2	-0.570896	0.144799	0.645502	0.257636	0.011363	0.069934	0.001474	0.007821	0.000055	0.004763	...	-0.000032	0.000498	0.001595	0.000222	-0.000315	0.017102	0.000110	-0.000067	-0.037651	0.037651

Composante	Variance Expliquée (%)	Variance Cumulée (%)	Interprétation
PC1	15.65	15.65	Capture la plus grande partie de la variance. Liée à richesse en capital.
PC2	11.37	27.02	Deuxième dimension importante. Liée à statut socio-professionnel.
PC3	10.70	37.72	Troisième dimension. Contribue à expliquer davantage de variance.
PC4	10.34	48.06	Quatrième dimension. Ajoute une part significative de variance.
PC5	9.36	57.42	Cinquième dimension. Cumul atteint 57.42%.
...	...	...	...
PC10	2.31	77.60	Après 10 composantes, 77.60% de la variance est expliquée.
PC20	0.84	90.36	Après 20 composantes, 90.36% de la variance est expliquée.
PC30	0.36	95.61	Après 30 composantes, 95.61% de la variance est expliquée.
PC50	0.05	99.27	Après 50 composantes, 99.27% de la variance est expliquée.

Critère	Nombre de Composantes	Variance Cumulée (%)	Interprétation
Scree Plot (Coude)	5	57.42	Le "coude" suggère de retenir 5 composantes pour une réduction optimale.
Variance Cumulée > 80%	13	82.71	Pour conserver 80% de la variance, retenir 13 composantes.
Variance Cumulée > 90%	20	90.36	Pour conserver 90% de la variance, retenir 20 composantes.

Composante	Variables Fortement Contributives	Interprétation
PC1	`capital-gain`, `capital-loss`	Représente la richesse en capital. Les individus avec des gains ou pertes en capital importants ont des scores élevés sur PC1.
PC2	`education-num`, `hours-per-week`	Représente le statut socio-professionnel. Les individus avec un niveau d'éducation élevé et travaillant de longues heures ont des scores élevés sur PC2.
PC3	`age`, `marital-status`	Pourrait représenter une dimension démographique (âge et situation familiale).
PC4	`occupation`, `relationship`	Pourrait représenter une dimension liée au type d'emploi et aux relations familiales.
PC5	`race`, `sex`	Pourrait représenter une dimension liée à la diversité démographique (race et sexe).

Élément Visualisé	Description
Scree Plot	Graphique montrant la variance expliquée par chaque composante. Aide à identifier le "coude".
Projection des Individus (PC1-PC2)	Nuage de points montrant la distribution des individus dans le plan PC1-PC2. Coloré par `income`.
Biplot	Combinaison des projections des individus et des contributions des variables.
Contributions des Variables	Diagrammes en barres montrant l'importance des variables dans les composantes principales.

Élément	Description
Réduction de Dimensionnalité	L'ACP permet de réduire la dimensionnalité tout en conservant une grande partie de la variance. Par exemple, 10 composantes expliquent 77.60% de la variance.
Interprétation des Dimensions	Les deux premières composantes principales représentent des dimensions liées à la richesse en capital (PC1) et au statut socio-professionnel (PC2).
Visualisation	Les biplots et les graphiques de variance expliquée aident à comprendre la structure des données.
Recommandations	- Retenir 5 à 13 composantes pour conserver 57% à 83% de la variance. - Examiner les charges factorielles des composantes supplémentaires pour une interprétation plus fine.

Nombre de Composantes	Variance Expliquée (%)	Variance Cumulée (%)	Interprétation
1	15.65	15.65	PC1 : Richesse en capital.
2	11.37	27.02	PC2 : Statut socio-professionnel.
3	10.70	37.72	PC3 : Dimension démographique (âge, situation familiale).
4	10.34	48.06	PC4 : Type d'emploi et relations familiales.
5	9.36	57.42	PC5 : Diversité démographique (race, sexe).
10	2.31	77.60	Après 10 composantes, 77.60% de la variance est expliquée.
20	0.84	90.36	Après 20 composantes, 90.36% de la variance est expliquée.

	Dimension	Inertie (%)
0	Dim1	62.665988
1	Dim2	37.334012

EXAMEN STATISTIQUE MULTIVARIEE 2025¶

Master Calcul Scientifique et Modelisation |¶

Etudiant : YAYA TOURE | Email : yaya.toure@unchk..edu.sn¶

Enseignant: Dr PO CISSE¶

Introduction : Analyse des Facteurs Influant sur le Niveau de Revenu¶

Défis et Enjeux du Projet¶

Remarque :¶

Dans le but d'eviter de remonter a chaque fois pour executer les packages,¶

nous avons opte de mettre les packages dans chaque cellule concernant l'etape de travail.¶

Téléchargement des Données¶

Prétraitement des Données : Gestion des Valeurs Manquantes avec "?"¶

Mise en Évidence des Anomalies¶

Comprendre les Doublons dans le Dataset Adult¶

Introduction¶

Gestion des doublons¶

La Data Science : bien plus qu’un nettoyage automatique¶

Résumé : Comprendre les doublons dans le dataset Adult¶

Détection Erronée des Valeurs Manquantes avec sidetable¶

Preuve de l’Anomalie :¶

Doublon dans notre data set¶

Analyse des Valeurs Manquantes : Uniquement dans les Variables Catégorielles¶

Pourquoi ces valeurs sont-elles manquantes ?¶

Que faire face à ces valeurs manquantes ?¶

AVANT OPTIMISATION¶

APRES OPTIMISATION¶

Analyse de l'amélioration du modèle après l'optimisation¶

1️⃣ Comparaison des Modèles Avant & Après¶

2️⃣ Points Positifs du Nouveau Modèle ✅¶

3️⃣ Ce qui a changé dans les variables¶

Variables supprimées (peu significatives ou multicolinéaires) :¶

Variables conservées et renforcées :¶

Toutefois nous allons pousser l'analyse , meme si nous connaissons les variables les plus influentes¶

Description de l'Analyse en Composantes Principales (ACP)¶

Objectifs de l'ACP¶

Étapes de l'ACP¶

Applications de l'ACP¶

Avantages de l'ACP¶

Limites de l'ACP¶

Exemple d'Application¶

Les packages¶

Rappellons les etapes que nous avons fait dans la partie : Régression Multiple¶

Étape 1: Prétraitement des données¶

Gestion des valeurs manquantes : Remplacer les valeurs "?" par NaN pour les traiter comme des valeurs manquantes.¶

Encodage des variables catégorielles : Convertir les variables catégorielles en variables numériques à l'aide de l'encodage one-hot.¶

Normalisation des données : Normaliser les données pour que chaque variable ait une moyenne de 0 et un écart-type de 1.¶

Étape 2: Application de l'ACP¶

-Instancier l'ACP : Utilisons PCA de sklearn.decomposition.¶

-Ajustons et transformons les données : Appliqueons l'ACP sur les données prétraitées.¶

Étape 3: Visualisation des résultats¶

Visualiser les composantes principales : Utiliser hvplot pour visualiser les deux premières composantes principales.¶

Étape 4: Interprétation des résultats¶

Expliqueons la variance : en Examinant la variance expliquée par chaque composante principale.¶

Interprétation des composantes : Analyser les contributions des variables originales aux composantes principales¶

Analyse et Interprétation des Résultats de l'ACP¶

Tableau 1 : Variance Expliquée par les Composantes Principales¶

Tableau 2 : Sélection du Nombre de Composantes¶

Tableau 3 : Interprétation des Composantes Principales¶

Tableau 4 : Visualisation des Résultats¶

Tableau 5 : Conclusion et Recommandations¶

Analyse et Interprétation du Scree Plot¶

Description du Graphique¶

Observations Clés¶

Interprétation¶

Tableau Récapitulatif¶

Conclusion¶

Interessant poursuivons pour avoir une separation Net¶

Nous allons evaluer l'importance de PCA1¶

Introduction¶

L'Analyse Factorielle des Correspondances (AFC) est une méthode statistique qui permet d'explorer les relations entre deux variables catégorielles.¶

Dans cette analyse, nous alons étudié les correspondances entre les niveaux d'éducation et les professions à partir du jeu de données Adult Income.¶

Le biplot résultant nous permet de visualiser ces relations dans un espace à deux dimensions.¶

Analyse et Interprétation du Biplot de l'AFC : Éducation vs. Occupation¶

1. Explication du Graphique¶

2. Interprétation des Résultats¶

a) Relation entre éducation et emploi¶

b) Analyse des Axes Factorielles¶

c) Structure Globale¶

3. Conclusions¶

Détection Erronée des Valeurs Manquantes avec `sidetable`¶